/**
 * @Project POL3Cay
 * @Author Tran Manh Hung
 * @Email: hungtmit@gmail.com | tmh@xwebgate.com
 * @Copyright © 2011 TMH. All rights reserved
 * @Createdate Feb 23, 2011
 * @Createtime 11:44:50 AM
 */

package com.gigalaxy.game.card
{
	import com.gigalaxy.game.card.phom.PhomHandComparator;

	import flash.display.Sprite;
	import flash.external.ExternalInterface;
	import flash.filters.DropShadowFilter;
	import flash.filters.GlowFilter;
	import flash.geom.Point;

	public class BaseHandRenderer extends Sprite
	{
		public static const CARD_SIZE_BIG:uint = 1;

		public static const CARD_SIZE_MEDIUM:uint = 2;

		public static const CARD_SIZE_SMALL:uint = 4;

		private var _cardSize:uint;

		protected var _openAngle:int = 0;

		protected var _radius:int = 0;

		private var _cardsSetRenderer:Vector.<CardRenderer>;

		private var _zoneAnchor:Point = new Point();

		private var cardThrowZOrder:int = 0;

		public var zoneHeight:Number = 64;

		public var zoneWidth:Number = 40;

		private var dropShadowFilter:DropShadowFilter;

		private var globalTableCenter:Point;
		private var MAX_THROW_CARDS:uint = 13;

		private var phomHandComparator:PhomHandComparator;

		private var _numCards:int; // number of card on hand

		public static var SIZE:uint = 10; // max cards on hand

		/**
		 * Căn chỉnh bài: trái | giữa | phải<br />
		 * 0: trái<br />
		 * 1: phải<br />
		 * 2: giữa (chiều ngang)<br />
		 * 3: trên<br />
		 * 4: dưới<br />
		 * 5: giữa (chiều dọc)<br />
		 */
		public var align:uint = 0;
		private static var ALIGN_LEFT:uint = 0;
		private static var ALIGN_RIGHT:uint = 1;
		private static var ALIGN_CENTER:uint = 2;
		private static var ALIGN_TOP:uint = 3;
		private static var ALIGN_BOTTOM:uint = 4;
		private static var ALIGN_MIDDLE:uint = 5;

		private var gap:int = 8;

		public static var BIG_SIZE_WIDTH:int = 96;
		public static var BIG_SIZE_HEIGHT:int = 128;
		public static var MEDIUM_SIZE_WIDTH:int = 52;
		public static var MEDIUM_SIZE_HEIGHT:int = 72;
		public static var SMALL_SIZE_WIDTH:int = 24;
		public static var SMALL_SIZE_HEIGHT:int = 32;

		public function BaseHandRenderer(cardSize:uint = CARD_SIZE_MEDIUM)
		{
			super();

			_cardsSetRenderer = new Vector.<CardRenderer>();

			globalTableCenter = new Point();

			dropShadowFilter = new DropShadowFilter(1, 135, 0, .6, 4, 4);

			//for (var i:int = 0; i < Deck.SIZE; i++)
			for (var i:int = 0; i < SIZE; i++)
			{
				_cardsSetRenderer[i] = new CardRenderer(new Card());
				//_cardsSetRenderer[i].filters = [glowFilter];
				_cardsSetRenderer[i].filters = [dropShadowFilter];

				addChild(_cardsSetRenderer[i]);
			}

			this.cardSize = cardSize;

			_numCards = 0;

			phomHandComparator = new PhomHandComparator();
		}

		public function sortPhom():void
		{
			phomHandComparator.resetData();
			phomHandComparator.setHandData(_cardsSetRenderer); // cần xem xét tại sao lại phải gán lại!!!????
			phomHandComparator.computeRank();

			sort();
		}

		public function sortPhomByJS(takenCard:String = ""):void
		{
			var a:Array = ExternalInterface.call("getPhoms", toStringExt(), takenCard);
			phomHandComparator.resetData();
			phomHandComparator.cardSets = _cardsSetRenderer;
			phomHandComparator.computeRankBaseOnGroups(a);

			sort();
		}

		public function sort():void
		{
			_cardsSetRenderer.sort(sortByRank); // sắp xếp bài!!!

			var j:int = 0;

			/*
			dồn bài!!!
			những bài trên tay sẽ lên trước. những bài không trên tay sẽ ở đằng sau!!!
			//*/
			for (var i:int = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					setChildIndex(_cardsSetRenderer[i], j);
					j++;
				}
			}
		}

		private function sortByRank(a:CardRenderer, b:CardRenderer):int
		{
			var ret:int = 0;

			if (a.card.sortRank < b.card.sortRank)
			{
				ret = -1;
			}
			else if (a.card.sortRank > b.card.sortRank)
			{
				ret = 1;
			}
			else
			{

				if (a.card.rank < b.card.rank)
				{
					ret = -1;
				}
				else if (a.card.rank > b.card.rank)
				{
					ret = 1;
				}
				else // a==b
				{
					if (a.card.suitRank < b.card.suitRank)
					{
						ret = -1;
					}
					else if (a.card.suitRank > b.card.suitRank)
					{
						ret = 1;
					}
					else // never reach here
					{
						ret = 0;
					}
				}
			}

			return ret;
		}

		/**
		 * apply visual change to card set ON HAND<br />
		 * @param allCard
		 */
		public function render(allCard:Boolean = false):void
		{
			//for (var i:uint = 0; i < Deck.SIZE; i++)
			for (var i:int = 0; i < SIZE; i++)
			{
				if (allCard)
				{
					_cardsSetRenderer[i].x = _cardsSetRenderer[i].cardVSO.x;
					_cardsSetRenderer[i].y = _cardsSetRenderer[i].cardVSO.y;
					_cardsSetRenderer[i].rotation = _cardsSetRenderer[i].cardVSO.rotation;
				}
				else
				{
					if (_cardsSetRenderer[i].onHand)
					{
						_cardsSetRenderer[i].x = _cardsSetRenderer[i].cardVSO.x;
						_cardsSetRenderer[i].y = _cardsSetRenderer[i].cardVSO.y;
						_cardsSetRenderer[i].rotation = _cardsSetRenderer[i].cardVSO.rotation;
					}
				}
			}
		}

		/**
		 * note: cần gọi hàm throw trước!!!
		 * @param gap: gap between card in cards line<br />
		 * @param isHorizontal: horizontal or vertical layout<br />
		 * @param rotationRange: rotation range (-rotationRange >>> rotationRange) of each card in card line<br />
		 * @param scaleAfter: scale of each card in cards line after throw
		 */
		public function computeThrowLine(gap:int = 24, isHorizontal:Boolean = true, rotationRange:Number = 0, scaleAfter:Number = 1):void
		{
			/**
			 * position of current threw card in threw line
			 */
			var position:int = 0; // cards threw

			/**
			 * how many cards threw
			 */
			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				/**
				 * Do trước đó card đã được throw (gọi hàm throw) nên mới check card không ở trên tay
				 * >>> TODO cần sửa đổi để không cần gọi hàm throw trước!!!
				 */
				if (!_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected) // not on hand and selected
				{
					_cardsSetRenderer[i].rotation = 0; // if not reset rotationZ to 0 it will skew card

					_cardsSetRenderer[i].width *= scaleAfter;
					_cardsSetRenderer[i].height *= scaleAfter;

					position++;
				}
			}

			var cPoint:Point = new Point();

			/**
			 * offsetX to align center threw cards set
			 */
			//var offsetX:int = 0;

			//** center card throw position
			var offsetX:int = (MAX_THROW_CARDS - position) * gap / 2;
			cPoint.x = Math.round(_zoneAnchor.x + offsetX + zoneWidth * Math.random());

			//*/

			/** random card throw position
			var offsetX:int = (13 - position) * 15;
			cPoint.x = Math.round(_zoneAnchor.x + (offsetX + zoneWidth) * Math.random());
			//*/

			cPoint.y = Math.round(_zoneAnchor.y + zoneHeight * Math.random());

			position = 0;

			for (i = 0; i < _cardsSetRenderer.length; i++)
			{
				if (!_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected) // not on hand and selected
				{
					if (isHorizontal)
					{
						_cardsSetRenderer[i].cardVSO.x = cPoint.x + position * gap;
						_cardsSetRenderer[i].cardVSO.y = cPoint.y;
						_cardsSetRenderer[i].cardVSO.rotation = -rotationRange + Math.random() * 2 * rotationRange; // rotation a bit for good look anh feel

						/**
						 * last throw card alway on top of previous threw cards
						 */
						setChildIndex(_cardsSetRenderer[i], cardThrowZOrder);
					}

					position++;
					cardThrowZOrder++;

					_cardsSetRenderer[i].selected = false;
				}
			}
		}

		/**
		 * note: cần gọi hàm throw trước!!!<br />
		 * tính toán đánh bài tới 1 điểm<br />
		 * note: chỉ tính toán cho duy nhất 1 quân bài!!!<br />
		 * @param globalX: tọa độ x của điểm đích mà quân bài di chuyển tới GLOBAL!
		 * @param globalY: tọa độ y của điểm đích mà quân bài di chuyển tới GLOBAL!
		 */
		public function computeThrowPoint(globalX:Number, globalY:Number, rotationRange:Number = 0):void
		{
			var localTarget:Point = globalToLocal(new Point(globalX, globalY));

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (!_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected) // not on hand and selected
				{
					_cardsSetRenderer[i].cardVSO.x = localTarget.x;
					_cardsSetRenderer[i].cardVSO.y = localTarget.y;
					_cardsSetRenderer[i].cardVSO.rotation = -rotationRange + Math.random() * 2 * rotationRange; // rotation a bit for good look anh feel

					_cardsSetRenderer[i].selected = false;

					return; // chỉ tính toán cho 1 card
				}
			}
		}

		/**
		 * THROW ALL SELECTED CARD ON HAND<br />
		 * ~ set on hand of selected cards = false
		 */
		public function throwCard(visible:Boolean = true):String
		{
			var res:String = "";

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected)
				{
					_cardsSetRenderer[i].onHand = false;

					_cardsSetRenderer[i].selected = visible; // !!!

					_cardsSetRenderer[i].visible = visible;

					_numCards--;

					res += _cardsSetRenderer[i].card.toStringExt() + " ";
				}
			}

			return res;
		}

		public function computeRenderCurve(openAngle:int = 150, radius:int = 180):void
		{
			var position:int = 1;

			//var stepAngle:Number = openAngle / (_baseHand.numCards + 1);
			var stepAngle:Number = openAngle / 14; // 14 = 13+1
			// var offsetAngle:Number = (openAngle - 180) / 2; // to center hand card
			var offsetAngle:Number = (openAngle - 180 + stepAngle * (13 - _numCards)) / 2; // to center hand card

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					_cardsSetRenderer[i].cardVSO.y = radius * Math.sin((offsetAngle + position * stepAngle - openAngle) / 180 * Math.PI);
					_cardsSetRenderer[i].cardVSO.x = radius * Math.cos((offsetAngle + position * stepAngle - openAngle) / 180 * Math.PI);
					_cardsSetRenderer[i].cardVSO.rotation = (90 + offsetAngle + position * stepAngle - openAngle) % 360;

					position++;
				}
			}

			_radius = radius;
			_openAngle = openAngle;
		}

		/**
		 * tính toán dữ liệu để hiển thị card theo đường thẳng<br />
		 * @param gap int: khoảng cách giữa các lá bài<br />
		 */
		public function computeRenderLine(gap:int = 36):void
		{
			var position:int = 0;
			var offset:int;

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					this.gap = gap;

					switch (align)
					{
						case ALIGN_LEFT:
							_cardsSetRenderer[i].cardVSO.x = position * gap;
							_cardsSetRenderer[i].cardVSO.y = 0;
							break;
						case ALIGN_RIGHT:
							offset = (_numCards - 1) * gap;

							_cardsSetRenderer[i].cardVSO.x = position * gap - offset;
							_cardsSetRenderer[i].cardVSO.y = 0;
							break;
						case ALIGN_TOP:
							_cardsSetRenderer[i].cardVSO.y = position * gap;
							_cardsSetRenderer[i].cardVSO.x = 0;
							break;
						case ALIGN_BOTTOM:
							offset = (_numCards - 1) * gap;

							_cardsSetRenderer[i].cardVSO.y = position * gap - offset;
							_cardsSetRenderer[i].cardVSO.x = 0;
							break;
						case ALIGN_CENTER:
							break;
						case ALIGN_MIDDLE:
							break;
						default:
							break;
					}

					setChildIndex(_cardsSetRenderer[i], position);
					position++;
				}
			}
		}

		public function computeRenderCascade(offsetX:int, offsetY:int):void
		{
			var position:int = 0;

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					_cardsSetRenderer[i].cardVSO.x = position * offsetX;
					_cardsSetRenderer[i].cardVSO.y = position * offsetY;

					position++;
				}
			}
		}

		/**
		trả về index mới của card với vị trí hiện tại<br />
		-1 nếu không cần thay đổi
		*/
		public function computeCardIndexByPosition(c:CardRenderer):int
		{
			var res:int = -1;

			var preIndex:int = getChildIndex(c);
			var currentIndex:int = Math.floor(c.x / gap);

			currentIndex = Math.max(0, currentIndex);
			currentIndex = Math.min(currentIndex, _numCards - 1, numChildren - 1);

			if (preIndex != currentIndex)
			{
				res = currentIndex;

				var cSR:Vector.<CardRenderer> = _cardsSetRenderer.splice(preIndex, 1); // bỏ card tại chỉ số pre index ra khỏi bộ bài
				_cardsSetRenderer.splice(currentIndex, 0, cSR.pop()); // thêm 1 card vào bộ bài
			}
			else
			{
				c.x = preIndex * gap;
			}

			return res;
		}

		/**
		 * tọa độ tiếp theo của quân bài được lấy về tay khi render line
		 */
		public function nextLinePosition(gap:int = 30, isHorizontal:Boolean = true):Point
		{
			var localX:Number;
			var localY:Number;

			if (isHorizontal)
			{
				switch (align)
				{
					case ALIGN_LEFT:
						localX = _numCards * gap;
						localY = 0;
						break;
					case ALIGN_RIGHT:
						localX = 0;
						localY = 0;
						break;
					case ALIGN_CENTER:
						break;
					default:
						break;
				}
			}

			var globalTarget:Point = localToGlobal(new Point(localX, localY));

			return globalTarget;
		}

		public function computeRenderToTableCenter(globalTableCenter_:Point):void
		{
			// var localTableCenter:Point = globalToLocal(new Point(globalTableCenter.x, globalTableCenter.y));
			globalTableCenter = globalToLocal(new Point(globalTableCenter_.x, globalTableCenter_.y));

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					_cardsSetRenderer[i].cardVSO.x = globalTableCenter.x;
					_cardsSetRenderer[i].cardVSO.y = globalTableCenter.y;
					_cardsSetRenderer[i].cardVSO.rotation = 0;
				}
			}
		}

		public function computeHideThrewCard():void
		{
			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (!_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].revealed)
				{
					_cardsSetRenderer[i].revealed = false;
					_cardsSetRenderer[i].selected = false;

					_cardsSetRenderer[i].cardVSO.x = globalTableCenter.x + 400;
					_cardsSetRenderer[i].cardVSO.y = globalTableCenter.y;
					_cardsSetRenderer[i].cardVSO.rotation = 0;
				}
			}
		}

		public function hideThrewCard():void
		{
			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (!_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].visible) // không còn trên tay và đang hiện trên bàn!!!
				{
					_cardsSetRenderer[i].revealed = false;
					_cardsSetRenderer[i].selected = false;
					_cardsSetRenderer[i].visible = false;
				}
			}
		}

		public function resetData():void
		{
			_numCards = 0;

			//for (var i:uint = 0; i < Deck.SIZE; i++)
			for (var i:int = 0; i < SIZE; i++)
			{
				_cardsSetRenderer[i].resetData();
			}

			cardSize = _cardSize; // reset card size

			_radius = 0;
			_openAngle = 0;
			cardThrowZOrder = 0;

			visible = false;
			alpha = 1;
		}

		public function computeMoveAllThrewCard(offX:Number, offY:Number):void
		{
			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				if (!_cardsSetRenderer[i].onHand) // not on hand and visible
				{
					_cardsSetRenderer[i].cardVSO.x += offX;
					_cardsSetRenderer[i].cardVSO.y += offY;
				}
			}
		}

		/**
		 * set cards will be throw by a string
		 */
		public function setCardsThrowString(cardsString:String, revealCard:Boolean = true, selectCard:Boolean = true):void
		{
			var cardStrings:Array = cardsString.split(' ');

			var cardIndex:uint = 0;

			var card:Card;

			//for (var i:int = 0; i < Deck.SIZE; i++)
			for (var i:int = 0; i < SIZE; i++)
			{
				if (_cardsSetRenderer[i].onHand)
				{
					card = stringToCard(cardStrings[cardIndex]);

					_cardsSetRenderer[i].card.setCard(card.value, card.suit);
					_cardsSetRenderer[i].revealed = revealCard;
					_cardsSetRenderer[i].selected = selectCard;

					cardIndex++;

					if (cardIndex == cardStrings.length)
					{
						break;
					}
				}
			}
		}

		/**
		 * reset current hand and receive new card set<br />
		 * dữ liệu trả về là số quân bài được nhận
		 */
		public function receiveCardsString(cardsString:String, revealCard:Boolean = false, interactable:Boolean = false):int
		{
			var preVisible:Boolean = visible; // giá trị visible trước khi reset

			resetData();

			var cardStrings:Array = cardsString.split(' ');

			var numCardsReceive:uint = 0; // để đảm bảo không có card null ở giữa bộ bài

			var card:Card;

			for (var i:int = 0; i < cardStrings.length; i++)
			{
				card = stringToCard(cardStrings[i]);

				if (card != null)
				{
					receiveCard(card, numCardsReceive, revealCard, interactable); // ERR
					numCardsReceive++;
				}
			}

			visible = preVisible; // giá trị visible không thay đổi sau khi nhận card

			return numCardsReceive;
		}

		/**
		 * hightlight card sử dụng 1 chuỗi string<br />
		 * cardsString: chuỗi nhập vào có dạng A♥ A♦ A♠ A♣<br />
		 * hightlight: kiểu hightlight - xem thêm giá trị highlight trong card render<br />
		 * selectedAfter: select card sau khi highlight
		 */
		public function highlightCardsByString(cardsString:String, highlight:uint = 0, selectedAfter:Boolean = false):void
		{
			selectCardsByString(cardsString);

			highlightSelectedCard(highlight, selectedAfter);
		}

		/**
		 * hightlight card đang được chọn
		 */
		public function highlightSelectedCard(highlight:uint = 0, selectedAfter:Boolean = false):void
		{
			for (var i:int = 0; i < SIZE; i++)
			{
				if (_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected) // on hand and selected
				{
					_cardsSetRenderer[i].highlight = highlight;
					_cardsSetRenderer[i].selected = selectedAfter;
				}
			}
		}

		public function blinkSelectedCard(blink:uint = 0, selectedAfter:Boolean = false):void
		{
			for (var i:int = 0; i < SIZE; i++)
			{
				if (_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected) // on hand and selected
				{
					_cardsSetRenderer[i].blink = blink;
					_cardsSetRenderer[i].selected = selectedAfter;
				}
			}
		}


		public function selectCardsByString(cardsString:String):void
		{
			var cardStrings:Array = cardsString.split(' ');

			for (var i:int = 0; i < cardStrings.length; i++)
			{
				selectCardByString(cardStrings[i]);
			}
		}

		private function selectCardByString(card:String):void
		{
			card = card.replace(' ', ''); // remove all space!!!

			for (var i:uint = 0; i < _cardsSetRenderer.length; i++)
			{
				/*
				Bài trên tay
				*/
				if (_cardsSetRenderer[i].onHand)
				{
					if (_cardsSetRenderer[i].card.toStringExt() == card)
					{
						_cardsSetRenderer[i].selected = true;
					}
				}
			}
		}

		public function selectCardByIndex(index:int, selected:Boolean = true):void
		{
			if (index >= 0)
			{
				_cardsSetRenderer[index].selected = selected;
			}
		}

		/**
		 * đặt giá trị select cho last card
		 */
		public function selectLastCard(selected:Boolean = true):void
		{
			selectCardByIndex(_numCards - 1, selected);
		}

		/**
		 * index from 0. index + 1 = position of card on hand
		 * _cardsSetRender index from 0
		 */
		public function receiveCard(card:Card, index:int, revealCard:Boolean = false, interactable:Boolean = false):void
		{
			if (card != null)
			{
				_cardsSetRenderer[index].onHand = true;

				_cardsSetRenderer[index].visible = true;

				_cardsSetRenderer[index].revealed = revealCard;

				_cardsSetRenderer[index].interactable = interactable;

				_cardsSetRenderer[index].card.setCard(card.value, card.suit);

				_numCards++;

				setChildIndex(_cardsSetRenderer[index], index);
			}
		}

		/**
		 * tính toán move card tới 1 vị trí<br />
		 * @param index: index của card trên tay. nhận giá trị từ 0 tới num card -1
		 * @param globalX: giá trị x của vị trí đích GLOBAL!
		 * @param globalY: giá trị y của vị trí đích GLOBAL!
		 */
		public function computeMoveCard(index:int, globalX:Number, globalY:Number):void
		{
			if (index >= 0)
			{
				var localTarget:Point = globalToLocal(new Point(globalX, globalY));

				_cardsSetRenderer[index].cardVSO.x = localTarget.x;
				_cardsSetRenderer[index].cardVSO.y = localTarget.y;
			}
		}

		/**
		 * Tính toán để đưa những quân bài được select tới vị trí nhất định<br />
		 * need TEST!!!
		 */
		public function computeMoveSelectedCard(globalX:Number, globalY:Number):void
		{
			for (var i:int = 0; i < SIZE; i++)
			{
				if (_cardsSetRenderer[i].onHand && _cardsSetRenderer[i].selected)
				{
					computeMoveCard(i, globalX, globalY);

					_cardsSetRenderer[i].selected = false;
				}
			}
		}

		/**
		 * tính toán di chuyển quân bài cuối cùng trên tay
		 */
		public function computeMoveLastCard(globalX:Number, globalY:Number):void
		{
			computeMoveCard(_numCards - 1, globalX, globalY);
		}

		/**
		 * TODO: Cần phải check card VALIDATE!!!!!
		 */
		public static function stringToCard(cardString:String):Card
		{
			cardString = cardString.split(" ").join(); // remove all spaces

			var value:String;

			var suitChar:String

			if (cardString.length == 3) // 10
			{
				value = "10";

				suitChar = cardString.charAt(2);
			}
			else if (cardString.length == 2) // length == 2
			{
				value = cardString.charAt(0);

				suitChar = cardString.charAt(1);
			}
			else
			{
				return null;
			}

			var card:Card = new Card();
			card.value = value;
			card.suit = suitChar;

			return card;
		}

		public function toStringExt(allCard:Boolean = false):String
		{
			var ret:String = "";

			//for (var i:uint = 0; i < Deck.SIZE; i++)
			for (var i:int = 0; i < SIZE; i++)
			{
				if (allCard)
				{
					ret += _cardsSetRenderer[i].card.toStringExt() + " ";
				}
				else
				{
					if (_cardsSetRenderer[i].onHand)
					{
						ret += _cardsSetRenderer[i].card.toStringExt() + " ";
					}
				}
			}

			return ret;
		}

		public function get radius():int
		{
			return _radius;
		}

		public function set radius(value:int):void
		{
			if (_radius != value)
			{
				computeRenderCurve(_openAngle, _radius);

				_radius = value;
			}
		}

		public function get openAngle():int
		{
			return _openAngle;
		}

		public function set openAngle(value:int):void
		{
			if (_openAngle != value)
			{
				computeRenderCurve(_openAngle, _radius);

				_openAngle = value;
			}
		}

		public function get cardsSetRender():Vector.<CardRenderer>
		{
			return _cardsSetRenderer;
		}

		public function get zoneAnchor():Point
		{
			return _zoneAnchor;
		}

		public function set zoneAnchor(value:Point):void
		{
			var localAnchor:Point = globalToLocal(new Point(value.x, value.y));

			_zoneAnchor = localAnchor;

			// _zoneAnchor = value
		}

		public function get cardSize():uint
		{
			return _cardSize;
		}

		/**
		 * @param value uint - BaseHandRenderer.CARD_SIZE_*
		 */
		public function set cardSize(value:uint):void
		{
			_cardSize = value;

			for (var i:int = 0; i < SIZE; i++)
			{
				switch (_cardSize)
				{
					case CARD_SIZE_BIG:
						_cardsSetRenderer[i].width = BIG_SIZE_WIDTH;
						_cardsSetRenderer[i].height = BIG_SIZE_HEIGHT;
						break;
					case CARD_SIZE_MEDIUM:
						_cardsSetRenderer[i].width = MEDIUM_SIZE_WIDTH;
						_cardsSetRenderer[i].height = MEDIUM_SIZE_HEIGHT;
						break;
					case CARD_SIZE_SMALL:
						_cardsSetRenderer[i].width = SMALL_SIZE_WIDTH;
						_cardsSetRenderer[i].height = SMALL_SIZE_HEIGHT;
						break;
					default:
						break;
				}
			}
		}

		public function get numCards():int
		{
			return _numCards;
		}

	}
}


